﻿﻿using jiuyuan.数据.共享类;
using jiuyuan.数据.基础数据类;
using jiuyuan.数据.玩家类;
using jiuyuan.服务;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.DependencyInjection;
using System.Text.Json;

namespace jiuyuan.管理器;

// 统一元素管理器
public class 元素管理器
{
    private readonly 事件总线 _事件总线;
    private readonly ILogger<元素管理器> _日志器;
    private readonly IServiceProvider _服务提供者; // 改为使用服务提供者
    private readonly 效果管理器 _效果管理器;
    private readonly Dictionary<Guid, 游戏元素> _元素字典 = [];
    private 配置加载器? _配置加载器; // 延迟初始化

    // 元素冷却跟踪
    private readonly Dictionary<string, DateTime> _元素冷却字典 = [];

    public 元素管理器(事件总线 事件总线, ILogger<元素管理器> 日志器, IServiceProvider 服务提供者, 效果管理器 效果管理器)
    {
        _事件总线 = 事件总线;
        _日志器 = 日志器;
        _服务提供者 = 服务提供者;
        _效果管理器 = 效果管理器;
        注册事件处理();
        加载元素数据();
    }

    // 延迟获取配置加载器，避免循环依赖
    private 配置加载器 获取配置加载器()
    {
        return _配置加载器 ??= _服务提供者.GetRequiredService<配置加载器>();
    }

    /// <summary>
    /// 注册元素
    /// </summary>
    public void 注册元素(游戏元素 元素)
    {
        _元素字典[元素.Id] = 元素;
        _日志器.LogInformation("注册游戏元素: {元素名称}, 类型: {元素类型}", 元素.名称, 元素.类型);
    }

    /// <summary>
    /// 根据ID获取元素
    /// </summary>
    public 游戏元素? 获取元素(Guid 元素ID)
    {
        return _元素字典.TryGetValue(元素ID, out var 元素) ? 元素 : null;
    }

    /// <summary>
    /// 获取所有元素
    /// </summary>
    public List<游戏元素> 获取所有元素()
    {
        return _元素字典.Values.ToList();
    }

    /// <summary>
    /// 根据类型获取元素
    /// </summary>
    public List<游戏元素> 根据类型获取元素(物品类型 类型)
    {
        return _元素字典.Values.Where(e => e.类型 == 类型).ToList();
    }

    /// <summary>
    /// 使用元素（统一处理所有类型）
    /// </summary>
    public async Task<操作结果> 使用元素(玩家 玩家, Guid 元素ID, List<战斗单位>? 目标列表 = null, 战斗管理器? 战斗管理器 = null)
    {
        var 元素 = 获取元素(元素ID);
        if (元素 == null)
            return 操作结果.失败("元素不存在");

        if (!元素.可使用)
            return 操作结果.失败("该元素不可使用");

        // 检查等级要求
        if (玩家.等级 < 元素.等级要求)
            return 操作结果.失败("等级不足");

        // 检查魔法值（仅技能）
        if (元素.类型 == 物品类型.技能 && 玩家.当前魔法值 < 元素.消耗魔法值)
            return 操作结果.失败("魔法值不足");

        // 检查冷却
        if (检查元素冷却(玩家.Id, 元素ID))
            return 操作结果.失败("元素还在冷却中");

        // 处理不同类型的元素
        var 结果 = 元素.类型 switch
        {
            物品类型.装备 => await 处理装备使用(玩家, 元素),
            物品类型.技能 => await 处理技能使用(玩家, 元素, 目标列表, 战斗管理器),
            物品类型.消耗品 => await 处理消耗品使用(玩家, 元素, 目标列表, 战斗管理器),
            物品类型.货币 or 物品类型.材料 or 物品类型.任务物品
                or 物品类型.收藏品 or 物品类型.钥匙 or 物品类型.特殊道具
                or 物品类型.道具 or 物品类型.技能书
                => await 处理特殊物品使用(玩家, 元素, 目标列表, 战斗管理器),
            _ => 操作结果.失败("不支持的元素类型")
        };

        if (结果.是否成功 && 元素.冷却时间 > 0)
        {
            设置元素冷却(玩家.Id, 元素ID, 元素.冷却时间);
        }

        return 结果;
    }

    /// <summary>
    /// 处理装备使用（穿戴）
    /// </summary>
    private async Task<操作结果> 处理装备使用(玩家 玩家, 游戏元素 装备)
    {
        if (!装备.可装备 || !装备.装备槽位.HasValue)
            return 操作结果.失败("该装备不可穿戴");

        // 检查槽位是否已被占用
        var 当前装备 = 获取槽位装备(玩家, 装备.装备槽位.Value);
        if (当前装备 != null)
        {
            // 先脱下当前装备
            await 脱下装备(玩家, 装备.装备槽位.Value);
        }

        // 从仓库移除装备
        var 仓库装备 = 玩家.仓库物品.FirstOrDefault(i => i.Id == 装备.Id);
        if (仓库装备 == null)
            return 操作结果.失败("装备不在仓库中");

        玩家.仓库物品.Remove(仓库装备);
        玩家.装备列表.Add(装备);

        // 应用装备效果
        await 应用元素效果(玩家, 装备);

        // 重新计算玩家属性
        玩家.重新计算属性();

        _日志器.LogInformation("玩家 {玩家名称} 穿戴装备 {装备名称}", 玩家.名称, 装备.名称);

        await _事件总线.发布事件(new 装备穿戴事件
        {
            玩家 = 玩家,
            装备 = 装备,
            槽位 = 装备.装备槽位.Value
        });

        return 操作结果.成功($"成功装备{装备.名称}");
    }

    /// <summary>
    /// 处理技能使用
    /// </summary>
    private async Task<操作结果> 处理技能使用(玩家 玩家, 游戏元素 技能, List<战斗单位> 目标列表, 战斗管理器 战斗管理器)
    {
        // 验证目标
        if (!验证目标有效性(技能.目标类型, 目标列表, 玩家))
            return 操作结果.失败("目标选择无效");

        // 消耗魔法值
        玩家.当前魔法值 -= 技能.消耗魔法值;

        // 应用技能效果
        foreach (var 效果 in 技能.效果列表.Where(e => e.触发时机 == 效果触发时机.立即触发))
        {
            if (new Random().NextDouble() <= 效果.触发概率)
            {
                效果.应用效果(玩家, 目标列表, 技能, 战斗管理器);
            }
        }

        _日志器.LogInformation("玩家 {玩家名称} 使用技能 {技能名称}", 玩家.名称, 技能.名称);

        await _事件总线.发布事件(new 技能使用事件
        {
            施法者 = 玩家,
            技能名称 = 技能.名称,
            目标列表 = 目标列表
        });

        return 操作结果.成功($"使用{技能.名称}成功");
    }

    /// <summary>
    /// 处理消耗品使用
    /// </summary>
    private async Task<操作结果> 处理消耗品使用(玩家 玩家, 游戏元素 消耗品, List<战斗单位> 目标列表, 战斗管理器 战斗管理器)
    {
        // 消耗物品数量
        var 消耗结果 = await 消耗元素(玩家, 消耗品.Id, 1);
        if (!消耗结果.是否成功)
            return 消耗结果;

        // 应用消耗品效果
        foreach (var 效果 in 消耗品.效果列表.Where(e => e.触发时机 == 效果触发时机.立即触发))
        {
            if (new Random().NextDouble() <= 效果.触发概率)
            {
                效果.应用效果(玩家, 目标列表, 消耗品, 战斗管理器);
            }
        }

        _日志器.LogInformation("玩家 {玩家名称} 使用消耗品 {消耗品名称}", 玩家.名称, 消耗品.名称);

        await _事件总线.发布事件(new 物品使用事件
        {
            玩家 = 玩家,
            物品 = 消耗品,
            目标列表 = 目标列表
        });

        return 操作结果.成功($"使用{消耗品.名称}成功");
    }

    /// <summary>
    /// 处理特殊物品使用
    /// </summary>
    private async Task<操作结果> 处理特殊物品使用(玩家 玩家, 游戏元素 物品, List<战斗单位> 目标列表, 战斗管理器 战斗管理器)
    {
        return 物品.类型 switch
        {
            物品类型.货币 => 操作结果.失败("货币不能直接使用"),
            物品类型.材料 => 操作结果.失败("材料需要用于合成或其他用途"),
            物品类型.任务物品 => await 处理任务物品使用(玩家, 物品, 目标列表, 战斗管理器),
            物品类型.收藏品 => 操作结果.失败("这是收藏品，无法使用"),
            物品类型.钥匙 => await 处理钥匙使用(玩家, 物品, 目标列表, 战斗管理器),
            物品类型.特殊道具 => await 处理特殊道具使用(玩家, 物品, 目标列表, 战斗管理器),
            物品类型.道具 => await 处理特殊道具使用(玩家, 物品, 目标列表, 战斗管理器),
            物品类型.技能书 => await 处理技能书使用(玩家, 物品, 目标列表, 战斗管理器),
            _ => 操作结果.失败("未知的物品类型")
        };
    }

    /// <summary>
    /// 处理任务物品使用
    /// </summary>
    private async Task<操作结果> 处理任务物品使用(玩家 玩家, 游戏元素 物品, List<战斗单位> 目标列表, 战斗管理器 战斗管理器)
    {
        // 这里可以添加任务物品的特殊逻辑
        // 例如：完成任务、触发剧情等

        _日志器.LogInformation("玩家 {玩家名称} 使用任务物品 {物品名称}", 玩家.名称, 物品.名称);

        await _事件总线.发布事件(new 任务物品使用事件
        {
            玩家 = 玩家,
            物品 = 物品
        });

        return 操作结果.成功($"使用了{物品.名称}");
    }

    /// <summary>
    /// 处理钥匙使用
    /// </summary>
    private async Task<操作结果> 处理钥匙使用(玩家 玩家, 游戏元素 物品, List<战斗单位> 目标列表, 战斗管理器 战斗管理器)
    {
        // 这里可以添加钥匙的特殊逻辑
        // 例如：开启宝箱、门等

        _日志器.LogInformation("玩家 {玩家名称} 使用钥匙 {物品名称}", 玩家.名称, 物品.名称);

        await _事件总线.发布事件(new 钥匙使用事件
        {
            玩家 = 玩家,
            钥匙 = 物品
        });

        return 操作结果.成功($"使用了{物品.名称}");
    }

    /// <summary>
    /// 处理特殊道具使用
    /// </summary>
    private async Task<操作结果> 处理特殊道具使用(玩家 玩家, 游戏元素 物品, List<战斗单位> 目标列表, 战斗管理器 战斗管理器)
    {
        // 应用特殊道具效果
        foreach (var 效果 in 物品.效果列表.Where(e => e.触发时机 == 效果触发时机.立即触发))
        {
            if (new Random().NextDouble() <= 效果.触发概率)
            {
                效果.应用效果(玩家, 目标列表, 物品, 战斗管理器);
            }
        }

        _日志器.LogInformation("玩家 {玩家名称} 使用特殊道具 {物品名称}", 玩家.名称, 物品.名称);

        await _事件总线.发布事件(new 特殊道具使用事件
        {
            玩家 = 玩家,
            道具 = 物品,
            目标列表 = 目标列表
        });

        return 操作结果.成功($"使用了{物品.名称}");
    }

    /// <summary>
    /// 处理技能书使用
    /// </summary>
    private async Task<操作结果> 处理技能书使用(玩家 玩家, 游戏元素 物品, List<战斗单位> 目标列表, 战斗管理器 战斗管理器)
    {
        // 这里可以添加学习技能的逻辑
        _日志器.LogInformation("玩家 {玩家名称} 使用技能书 {物品名称}", 玩家.名称, 物品.名称);

        await _事件总线.发布事件(new 技能书使用事件
        {
            玩家 = 玩家,
            技能书 = 物品
        });

        return 操作结果.成功($"使用了{物品.名称}");
    }

    /// <summary>
    /// 脱下装备
    /// </summary>
    public async Task<操作结果> 脱下装备(玩家 玩家, 装备槽位 槽位)
    {
        var 装备 = 获取槽位装备(玩家, 槽位);
        if (装备 == null)
            return 操作结果.失败("该槽位没有装备");

        // 从装备列表移除
        bool 移除成功 = 玩家.装备列表.Remove(装备);
        if (!移除成功)
            return 操作结果.失败("脱下装备失败");

        // 添加到仓库
        玩家.仓库物品.Add(装备);

        // 移除装备效果
        await 移除元素效果(玩家, 装备);

        // 重新计算玩家属性
        玩家.重新计算属性();

        _日志器.LogInformation("玩家 {玩家名称} 脱下装备 {装备名称} 从 {槽位} 槽位", 玩家.名称, 装备.名称, 槽位);

        await _事件总线.发布事件(new 装备脱下事件
        {
            玩家 = 玩家,
            装备 = 装备,
            槽位 = 槽位
        });

        return 操作结果.成功($"成功脱下{装备.名称}");
    }

    /// <summary>
    /// 应用元素效果
    /// </summary>
    private async Task 应用元素效果(玩家 玩家, 游戏元素 元素)
    {
        foreach (var 效果 in 元素.效果列表)
        {
            switch (效果.触发时机)
            {
                case 效果触发时机.常驻效果:
                    // 常驻效果立即应用到属性
                    if (效果 is 属性加成效果 属性效果)
                    {
                        玩家.当前属性 = 属性配置.合并属性(玩家.当前属性, 获取属性加成(属性效果));
                    }
                    break;

                case 效果触发时机.装备时:
                    // 装备时触发的效果
                    效果.应用效果(玩家, new List<战斗单位> { 玩家 }, 元素, null);
                    break;
            }
        }

        await Task.CompletedTask;
    }

    /// <summary>
    /// 移除元素效果
    /// </summary>
    private async Task 移除元素效果(玩家 玩家, 游戏元素 元素)
    {
        foreach (var 效果 in 元素.效果列表)
        {
            switch (效果.触发时机)
            {
                case 效果触发时机.常驻效果:
                    // 移除常驻属性加成
                    if (效果 is 属性加成效果 属性效果)
                    {
                        玩家.当前属性 = 属性配置.合并属性(玩家.当前属性, 获取负属性加成(属性效果));
                    }
                    break;

                case 效果触发时机.卸下时:
                    // 卸下时触发的效果
                    效果.应用效果(玩家, new List<战斗单位> { 玩家 }, 元素, null);
                    break;
            }
        }

        await Task.CompletedTask;
    }

    /// <summary>
    /// 获取属性加成
    /// </summary>
    private 属性配置 获取属性加成(属性加成效果 效果)
    {
        return new 属性配置
        {
            生命值 = 效果.参数.TryGetValue("生命值", out var hp) ? Convert.ToInt32(hp) : 0,
            魔法值 = 效果.参数.TryGetValue("魔法值", out var mp) ? Convert.ToInt32(mp) : 0,
            物理攻击 = 效果.参数.TryGetValue("物理攻击", out var atk) ? Convert.ToInt32(atk) : 0,
            物理防御 = 效果.参数.TryGetValue("物理防御", out var def) ? Convert.ToInt32(def) : 0,
            火属性攻击 = 效果.参数.TryGetValue("火属性攻击", out var fireAtk) ? Convert.ToInt32(fireAtk) : 0,
            水属性攻击 = 效果.参数.TryGetValue("水属性攻击", out var waterAtk) ? Convert.ToInt32(waterAtk) : 0,
            风属性攻击 = 效果.参数.TryGetValue("风属性攻击", out var windAtk) ? Convert.ToInt32(windAtk) : 0,
            土属性攻击 = 效果.参数.TryGetValue("土属性攻击", out var earthAtk) ? Convert.ToInt32(earthAtk) : 0,
            速度 = 效果.参数.TryGetValue("速度", out var speed) ? Convert.ToInt32(speed) : 0,
            幸运值 = 效果.参数.TryGetValue("幸运值", out var luck) ? Convert.ToInt32(luck) : 0
        };
    }

    /// <summary>
    /// 获取负属性加成（用于移除效果）
    /// </summary>
    private 属性配置 获取负属性加成(属性加成效果 效果)
    {
        var 加成 = 获取属性加成(效果);
        return new 属性配置
        {
            生命值 = -加成.生命值,
            魔法值 = -加成.魔法值,
            物理攻击 = -加成.物理攻击,
            物理防御 = -加成.物理防御,
            火属性攻击 = -加成.火属性攻击,
            水属性攻击 = -加成.水属性攻击,
            风属性攻击 = -加成.风属性攻击,
            土属性攻击 = -加成.土属性攻击,
            速度 = -加成.速度,
            幸运值 = -加成.幸运值
        };
    }

    /// <summary>
    /// 添加元素到仓库
    /// </summary>
    public async Task<操作结果> 添加元素到仓库(玩家 玩家, Guid 元素ID, int 数量 = 1)
    {
        var 元素 = 获取元素(元素ID);
        if (元素 == null)
            return 操作结果.失败("元素不存在");

        // 检查堆叠
        var 现有元素 = 玩家.仓库物品.FirstOrDefault(i => i.Id == 元素ID);
        if (现有元素 != null)
        {
            if (现有元素.数量 + 数量 > 元素.最大堆叠数)
                return 操作结果.失败("超过最大堆叠数量");

            现有元素.数量 += 数量;
        }
        else
        {
            var 新元素 = 元素.深拷贝();
            新元素.数量 = 数量;
            玩家.仓库物品.Add(新元素);
        }

        _日志器.LogInformation("玩家 {玩家名称} 获得元素 {元素名称} x{数量}", 玩家.名称, 元素.名称, 数量);

        await _事件总线.发布事件(new 获得物品事件
        {
            玩家 = 玩家,
            物品 = 元素,
            数量 = 数量
        });

        return 操作结果.成功($"获得{元素.名称} x{数量}");
    }

    /// <summary>
    /// 消耗元素
    /// </summary>
    public async Task<操作结果> 消耗元素(玩家 玩家, Guid 元素ID, int 数量 = 1)
    {
        // 先从仓库查找
        var 仓库元素 = 玩家.仓库物品.FirstOrDefault(i => i.Id == 元素ID);
        if (仓库元素 != null)
        {
            if (仓库元素.数量 < 数量)
                return 操作结果.失败("元素数量不足");

            仓库元素.数量 -= 数量;
            if (仓库元素.数量 <= 0)
                玩家.仓库物品.Remove(仓库元素);

            await _事件总线.发布事件(new 消耗物品事件
            {
                玩家 = 玩家,
                物品 = 仓库元素,
                数量 = 数量
            });

            return 操作结果.成功($"消耗{仓库元素.名称} x{数量}");
        }

        // 如果仓库没有，检查装备
        var 装备元素 = 玩家.装备列表.FirstOrDefault(i => i.Id == 元素ID);
        if (装备元素 != null)
        {
            // 装备不能直接消耗，需要先脱下
            return 操作结果.失败("请先脱下装备再消耗");
        }

        return 操作结果.失败("元素不存在");
    }

    /// <summary>
    /// 获取指定槽位的装备
    /// </summary>
    public 游戏元素? 获取槽位装备(玩家 玩家, 装备槽位 槽位)
    {
        return 玩家.装备列表.FirstOrDefault(e => e.可装备 && e.装备槽位 == 槽位);
    }

    /// <summary>
    /// 获取玩家所有装备
    /// </summary>
    public Dictionary<装备槽位, 游戏元素?> 获取玩家所有装备(玩家 玩家)
    {
        var 装备字典 = new Dictionary<装备槽位, 游戏元素?>();
        foreach (装备槽位 槽位 in Enum.GetValues<装备槽位>())
        {
            装备字典[槽位] = 获取槽位装备(玩家, 槽位);
        }
        return 装备字典;
    }

    /// <summary>
    /// 获取玩家货币数量
    /// </summary>
    public int 获取货币数量(玩家 玩家)
    {
        var 货币元素 = 玩家.仓库物品.FirstOrDefault(i => i.类型 == 物品类型.货币);
        return 货币元素?.数量 ?? 0;
    }

    /// <summary>
    /// 增加货币
    /// </summary>
    public async Task<操作结果> 增加货币(玩家 玩家, int 数量)
    {
        var 货币元素 = 玩家.仓库物品.FirstOrDefault(i => i.类型 == 物品类型.货币);
        if (货币元素 == null)
        {
            货币元素 = new 游戏元素
            {
                Id = Guid.NewGuid(),
                名称 = "金币",
                描述 = "通用货币",
                类型 = 物品类型.货币,
                最大堆叠数 = int.MaxValue
            };
            玩家.仓库物品.Add(货币元素);
        }

        货币元素.数量 += 数量;

        _日志器.LogInformation("玩家 {玩家名称} 获得 {数量} 金币", 玩家.名称, 数量);

        await _事件总线.发布事件(new 获得货币事件
        {
            玩家 = 玩家,
            数量 = 数量
        });

        return 操作结果.成功($"获得{数量}金币");
    }

    /// <summary>
    /// 减少货币
    /// </summary>
    public async Task<操作结果> 减少货币(玩家 玩家, int 数量)
    {
        var 货币元素 = 玩家.仓库物品.FirstOrDefault(i => i.类型 == 物品类型.货币);
        if (货币元素 == null || 货币元素.数量 < 数量)
            return 操作结果.失败("金币不足");

        货币元素.数量 -= 数量;

        _日志器.LogInformation("玩家 {玩家名称} 消耗 {数量} 金币", 玩家.名称, 数量);

        await _事件总线.发布事件(new 消耗货币事件
        {
            玩家 = 玩家,
            数量 = 数量
        });

        return 操作结果.成功($"消耗{数量}金币");
    }

    /// <summary>
    /// 检查元素冷却
    /// </summary>
    private bool 检查元素冷却(Guid 玩家Id, Guid 元素ID)
    {
        var 冷却键 = $"{玩家Id}_{元素ID}";
        if (_元素冷却字典.TryGetValue(冷却键, out var 冷却时间))
        {
            return 冷却时间 > DateTime.Now;
        }
        return false;
    }

    /// <summary>
    /// 设置元素冷却
    /// </summary>
    private void 设置元素冷却(Guid 玩家Id, Guid 元素ID, int 冷却时间秒)
    {
        var 冷却键 = $"{玩家Id}_{元素ID}";
        _元素冷却字典[冷却键] = DateTime.Now.AddSeconds(冷却时间秒);
    }

    /// <summary>
    /// 清理过期冷却
    /// </summary>
    public void 清理过期冷却()
    {
        var 过期键 = _元素冷却字典.Where(kv => kv.Value <= DateTime.Now)
                                .Select(kv => kv.Key)
                                .ToList();

        foreach (var 键 in 过期键)
        {
            _元素冷却字典.Remove(键);
        }
    }

    /// <summary>
    /// 验证目标有效性
    /// </summary>
    private bool 验证目标有效性(技能目标类型 目标类型, List<战斗单位> 目标列表, 战斗单位 施法者)
    {
        if (目标列表 == null || 目标列表.Count == 0)
            return 目标类型 == 技能目标类型.自身;

        switch (目标类型)
        {
            case 技能目标类型.自身:
                return 目标列表.Count == 1 && 目标列表[0] == 施法者;
            case 技能目标类型.友方单体:
                return 目标列表.Count == 1 && 目标列表[0].单位类型 == 施法者.单位类型;
            case 技能目标类型.敌方单体:
                return 目标列表.Count == 1 && 目标列表[0].单位类型 != 施法者.单位类型;
            case 技能目标类型.友方群体:
                return 目标列表.All(t => t.单位类型 == 施法者.单位类型);
            case 技能目标类型.敌方群体:
                return 目标列表.All(t => t.单位类型 != 施法者.单位类型);
            default:
                return false;
        }
    }

    /// <summary>
    /// 加载元素数据
    /// </summary>
    private void 加载元素数据()
    {
        try
        {
            // 延迟加载配置数据
            // 注意：在应用启动时，配置加载器会调用加载所有配置的方法
            // 这里不需要主动加载，避免循环依赖
            _日志器.LogInformation("元素管理器初始化完成，等待配置加载器加载数据");
        }
        catch (Exception ex)
        {
            _日志器.LogError(ex, "加载元素数据时发生错误");
        }
    }

    /// <summary>
    /// 保存游戏元素到数据库
    /// </summary>
    public async Task 保存元素到数据库(游戏元素 元素)
    {
        var 配置加载器 = 获取配置加载器();
        await 配置加载器.保存游戏元素(元素);
    }

    /// <summary>
    /// 从数据库加载所有元素
    /// </summary>
    public async Task 从数据库加载所有元素()
    {
        var 配置加载器 = 获取配置加载器();
        await 配置加载器.加载游戏元素配置();
    }

    /// <summary>
    /// 保存元素配置
    /// </summary>
    public async Task 保存元素配置(游戏元素 元素)
    {
        元素.更新时间 = DateTime.Now;
        _元素字典[元素.Id] = 元素;

        await _配置加载器.保存游戏元素(元素);
        _日志器.LogInformation("保存游戏元素: {元素名称}", 元素.名称);
    }

    /// <summary>
    /// 删除元素配置
    /// </summary>
    public async Task 删除元素配置(Guid 元素ID)
    {
        if (_元素字典.Remove(元素ID))
        {
            await _配置加载器.删除游戏元素(元素ID);
            _日志器.LogInformation("删除游戏元素: {元素ID}", 元素ID);
        }
    }

    /// <summary>
    /// 注册事件处理
    /// </summary>
    private void 注册事件处理()
    {
        // 处理战斗事件，触发元素效果
        _事件总线.订阅事件<战斗开始事件>(async 事件 =>
        {
            foreach (var 玩家 in 事件.战斗上下文.玩家队伍)
            {
                await 处理战斗开始效果(玩家, 事件.战斗上下文);
            }
        });

        _事件总线.订阅事件<回合开始事件>(async 事件 =>
        {
            foreach (var 玩家 in 事件.战斗上下文.玩家队伍.Where(p => p.是否存活))
            {
                await 处理回合开始效果(玩家, 事件.战斗上下文);
            }
        });

        _事件总线.订阅事件<攻击事件>(async 事件 =>
        {
            if (事件.攻击者 is 玩家 玩家)
            {
                await 处理攻击时效果(玩家, 事件.受击者, 事件.战斗上下文);
            }
        });

        _事件总线.订阅事件<受击事件>(async 事件 =>
        {
            if (事件.受击者 is 玩家 玩家)
            {
                await 处理受击时效果(玩家, 事件.攻击者, 事件.战斗上下文);
            }
        });
    }

    /// <summary>
    /// 处理战斗开始效果
    /// </summary>
    private async Task 处理战斗开始效果(玩家 玩家, 战斗上下文 战斗上下文)
    {
        // 处理装备的战斗开始效果
        foreach (var 装备 in 玩家.装备列表)
        {
            foreach (var 效果 in 装备.效果列表.Where(e => e.触发时机 == 效果触发时机.战斗开始))
            {
                if (new Random().NextDouble() <= 效果.触发概率)
                {
                    效果.应用效果(玩家, new List<战斗单位> { 玩家 }, 装备, 战斗上下文.战斗管理器);
                }
            }
        }
        
        // 处理技能的战斗开始效果
        foreach (var 技能 in 玩家.技能列表)
        {
            foreach (var 效果 in 技能.效果列表.Where(e => e.触发时机 == 效果触发时机.战斗开始))
            {
                if (new Random().NextDouble() <= 效果.触发概率)
                {
                    效果.应用效果(玩家, new List<战斗单位> { 玩家 }, 技能, 战斗上下文.战斗管理器);
                }
            }
        }
        
        await Task.CompletedTask;
    }

    /// <summary>
    /// 处理回合开始效果
    /// </summary>
    private async Task 处理回合开始效果(玩家 玩家, 战斗上下文 战斗上下文)
    {
        // 处理装备的回合开始效果
        foreach (var 装备 in 玩家.装备列表)
        {
            foreach (var 效果 in 装备.效果列表.Where(e => e.触发时机 == 效果触发时机.回合开始))
            {
                if (new Random().NextDouble() <= 效果.触发概率)
                {
                    效果.应用效果(玩家, new List<战斗单位> { 玩家 }, 装备, 战斗上下文.战斗管理器);
                }
            }
        }
        
        // 处理技能的回合开始效果
        foreach (var 技能 in 玩家.技能列表)
        {
            foreach (var 效果 in 技能.效果列表.Where(e => e.触发时机 == 效果触发时机.回合开始))
            {
                if (new Random().NextDouble() <= 效果.触发概率)
                {
                    效果.应用效果(玩家, new List<战斗单位> { 玩家 }, 技能, 战斗上下文.战斗管理器);
                }
            }
        }
        
        await Task.CompletedTask;
    }

    /// <summary>
    /// 处理攻击时效果
    /// </summary>
    private async Task 处理攻击时效果(玩家 玩家, 战斗单位 目标, 战斗上下文 战斗上下文)
    {
        // 处理装备的攻击时效果
        foreach (var 装备 in 玩家.装备列表)
        {
            foreach (var 效果 in 装备.效果列表.Where(e => e.触发时机 == 效果触发时机.攻击时))
            {
                if (new Random().NextDouble() <= 效果.触发概率)
                {
                    效果.应用效果(玩家, new List<战斗单位> { 目标 }, 装备, 战斗上下文.战斗管理器);
                }
            }
        }
        
        // 处理技能的攻击时效果
        foreach (var 技能 in 玩家.技能列表)
        {
            foreach (var 效果 in 技能.效果列表.Where(e => e.触发时机 == 效果触发时机.攻击时))
            {
                if (new Random().NextDouble() <= 效果.触发概率)
                {
                    效果.应用效果(玩家, new List<战斗单位> { 目标 }, 技能, 战斗上下文.战斗管理器);
                }
            }
        }
        
        await Task.CompletedTask;
    }

    /// <summary>
    /// 处理受击时效果
    /// </summary>
    private async Task 处理受击时效果(玩家 玩家, 战斗单位 攻击者, 战斗上下文 战斗上下文)
    {
        // 处理装备的受击时效果
        foreach (var 装备 in 玩家.装备列表)
        {
            foreach (var 效果 in 装备.效果列表.Where(e => e.触发时机 == 效果触发时机.受击时))
            {
                if (new Random().NextDouble() <= 效果.触发概率)
                {
                    效果.应用效果(玩家, new List<战斗单位> { 攻击者 }, 装备, 战斗上下文.战斗管理器);
                }
            }
        }
        
        // 处理技能的受击时效果
        foreach (var 技能 in 玩家.技能列表)
        {
            foreach (var 效果 in 技能.效果列表.Where(e => e.触发时机 == 效果触发时机.受击时))
            {
                if (new Random().NextDouble() <= 效果.触发概率)
                {
                    效果.应用效果(玩家, new List<战斗单位> { 攻击者 }, 技能, 战斗上下文.战斗管理器);
                }
            }
        }
        
        await Task.CompletedTask;
    }
}

// 新增事件类
public class 任务物品使用事件 : 游戏事件
{
    public 玩家 玩家 { get; set; } = null!;
    public 游戏元素 物品 { get; set; } = null!;
}

public class 钥匙使用事件 : 游戏事件
{
    public 玩家 玩家 { get; set; } = null!;
    public 游戏元素 钥匙 { get; set; } = null!;
}

public class 特殊道具使用事件 : 游戏事件
{
    public 玩家 玩家 { get; set; } = null!;
    public 游戏元素 道具 { get; set; } = null!;
    public List<战斗单位> 目标列表 { get; set; } = new();
}

public class 技能书使用事件 : 游戏事件
{
    public 玩家 玩家 { get; set; } = null!;
    public 游戏元素 技能书 { get; set; } = null!;
}

public class 获得货币事件 : 游戏事件
{
    public 玩家 玩家 { get; set; } = null!;
    public int 数量 { get; set; }
}

public class 消耗货币事件 : 游戏事件
{
    public 玩家 玩家 { get; set; } = null!;
    public int 数量 { get; set; }
}

public class 物品使用事件 : 游戏事件
{
    public 玩家 玩家 { get; set; } = null!;
    public 游戏元素 物品 { get; set; } = null!;
    public List<战斗单位> 目标列表 { get; set; } = new();
}

public class 装备穿戴事件 : 游戏事件
{
    public 玩家 玩家 { get; set; } = null!;
    public 游戏元素 装备 { get; set; } = null!;
    public 装备槽位 槽位 { get; set; }
}

public class 装备脱下事件 : 游戏事件
{
    public 玩家 玩家 { get; set; } = null!;
    public 游戏元素 装备 { get; set; } = null!;
    public 装备槽位 槽位 { get; set; }
}

public class 装备修理事件 : 游戏事件
{
    public 玩家 玩家 { get; set; } = null!;
    public 游戏元素 装备 { get; set; } = null!;
}

public class 装备损坏事件 : 游戏事件
{
    public 玩家 玩家 { get; set; } = null!;
    public 游戏元素 装备 { get; set; } = null!;
}

public class 单位死亡事件 : 游戏事件
{
    public 战斗单位 死亡单位 { get; set; } = null!;
    public 战斗单位? 击杀者 { get; set; }
}

// 操作结果类
public class 操作结果
{
    public bool 是否成功 { get; set; }
    public string 消息 { get; set; } = string.Empty;

    public static 操作结果 成功(string 消息 = "")
    {
        return new 操作结果 { 是否成功 = true, 消息 = 消息 };
    }

    public static 操作结果 失败(string 消息)
    {
        return new 操作结果 { 是否成功 = false, 消息 = 消息 };
    }
}